#define _CRT_SECURE_NO_WARNINGS 1
// 所有的成员函数的参数 都比看到的多一个，  就是this指针
#include <iostream>
using namespace std;
// class Date
//{
// public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	// 不能显示的写实参和形参
//	// void Print(Date* const this)
//	void Print()
//	{
//		//this = nullptr;
//		cout << this << endl;
//		// 但是可以在类里面显示的使用
//		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
// private:
//	int _year;     // 年
//	int _month;    // 月
//	int _day;      // 日
// };
//
// int main()
//{
//	Date d1;
//	d1.Init(2023, 10, 19);
//	Date d2;
//
//	d1.Print(); // d1.Print(&d1);
//	d2.Print();
//	return 0;
// }

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行  --------------------正常运行
//
// class A
//{
// public:
//	void Print()
//	{
//		cout << _a << endl;
//		cout << "Print()" << endl;
//	}
//// private:
//	int _a;
//};
//
// int main()
//{
//	A* p = nullptr;
//
//	// 成员函数的地址不在对象中
//	// 成员变量是存在对象中
//	p->Print();
//
//	//p->_a = 1;
//
//	return 0;
//}

// class Date
//{
// public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
// private:
//	int _year;
//	int _month;
//	int _day;
// };
//
////int main()
////{
////	// 忘记初始化？
////	Date d1;
////	d1.Print();
////
////	Date d2;
////	d2.Init(2022, 7, 6);
////	d2.Print();
////
////	// 忘记初始化？
////	Stack st;
////	st.Push(1);
////
////	return 0;
////}
//
// int main()
//{
//	// 忘记初始化？
//	Date d1;
//	d1.Print();
//
//	Date d2;
//	d2.Init(2022, 7, 6);
//	d2.Print();
//
//	// 忘记初始化？
//	Stack st;
//	st.Push(1);
//
//	return 0;
//}

/// ————————————————————————————————————————————————————————类与对象(中)

// ——————————————————————————————————————1. 类的6个默认成员函数
// ——————————————————————————————————————2. 构造函数

// class Date
//{
// public:
//	// 下面两个构成函数重载，但是无参调用存在歧义，两者不能同时存在
//
//	// 1.无参构造函数
//	// 当我们创建Date对象但没有提供任何参数时，编译器会自动调用这个构造函数。
//	//Date()
//	//{
//	//	_year = 1;
//	//	_month = 1;
//	//	_day = 1;
//	//}
//
//
//	//2.带参构造函数
//     //当我们创建Date对象并提供三个参数（年、月、日）时，编译器会自动调用这个构造函数。
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
// private:
//	int _year;
//	int _month;
//	int _day;
// };
//
//// Date f(); 函数声明
// int main()
//{
//	Date d1;//没有参数的时候就不要加括号
//	//因为很像函数声明，容易混淆，就这样了做了特殊处理。
//	// 调用无参构造函数来创建一个Date对象d1
//	// 实例化d1对象，此时d1的成员变量没有被初始化，它们将具有默认值（通常是0）
//	d1.Print();
//
//
//
//	Date d2(2023, 10, 19);
//	// 调用带参的构造函数来创建一个带有初始值的Date对象d2
//	// 实例化d2对象，并初始化其成员变量为2015年1月1日
//	d2.Print();
//
//
//
//	//缺省参数，缺少了第三个参数.
//	Date d3(2023, 10);
//	d3.Print();
//
//
//
//	// 注意：以下代码声明了一个名为d3的函数，而不是创建对象
//	// 该函数不接受任何参数，并返回一个Date类型的对象
//	// 这将导致混淆，因为从形式上看，它很像对象实例化
////	Data d4();/// 函数声明，不是对象实例化
//	return 0;
//}

// 特性 2.2.5
// 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
// 用户显式定义编译器将不再生成。

// class Date
//{
// public:
//	// 够成函数重载，但是无参调用存在歧义，不能同时存在
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//	// 默认生成的构造函数，啥事都干？---不是
//	// 处理自定义类型（会去调用这个成员的默认构造函数）
//	// 内置类型不确定(看编译器)，建议当成不处理
// private:
//	// C++11支持，声明时给缺省值
//	//以下是声明。  声明和定义的区别：定义需要开空间
//	int _year=1 ;
//	int _month=1;
//	int _day=1;
//	//如果上面三个没给定初始值，d1.Print()则打印随机值.(当成员变量没有初始值且编译器不提供默认初始化时，它们会包含不确定的值(通常是垃圾值))
//
// };
//
// class Stack
//{
// public:
//	//构造函数Stack(size_t capacity = 3)允许用户指定栈的容量，如果不指定，则默认为3。
//	Stack(size_t capacity = 3)
//	{
//		cout << "Stack(size_t capacity = 3)" << endl;
//
//		_a = (int*)malloc(sizeof(int) * capacity);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败!!!");
//		}
//
//		_capacity = capacity;
//		_top = 0;
//	}
//
// private:
//	int* _a;//是一个指向整数的指针，用于存储栈中的元素
//	int _capacity;
//	int _top;
// };
//
//// 两个栈实现一个队列
// class MyQueue
//{
// private:
//	Stack _pushst;
//	Stack _popst;
//	int _size = 1;
// };
//
// int main()
//{
//	Date d1;
//	d1.Print();
//
//	Stack st1;
//
//	MyQueue mq;
//
//	return 0;
// }
//	---以上总结：
// 对于Data类
// 如果没有显式定义构造函数，C++编译器会为类生成一个默认的无参构造函数。但在C++11及以后的版本中，如果类的成员变量有默认值，编译器
// 会自动使用这些默认值来初始化成员变量

// 为什么用 栈，队列 的例子
// 使用栈和队列是为了展示类的定义、构造函数的使用以及不同数据结构之间的关系。栈类是一个独立的实现，而队列类（尽管在这个代码片段中不完整）展示了如何使用其他类（在这个例子中是栈类）来构建更复杂的数据结构或功能。

// 特性 2.2.7
// 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
// 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
// 是默认构造函数。

// class Date
//{
// public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
// private:
//	// C++11支持，声明时给缺省值
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
// };
//
//// 1、我们不写编译器默认生成那个构造函数，叫默认构造
//// 2、无参构造函数也可以叫默认构造
//// 3、全缺省也可以叫默认构造
//// 可以不传参数就调用构造，都可以叫默认构造
//// 这三个函数不能同时存在，只能存在一个
//
// int main()
//{
//	Date d1;
//	d1.Print();
//
//	//Data d2(2023);
//	//d2.Print();
//
//	return 0;
//}

////////////——————————————————————————————析构函数

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    ~Date()
    {
        // 对于Date类来说，实际上并不需要析构函数，因为它没有分配任何需要释放的资源。
        // 成员变量_year、_month和_day都是内置类型，它们的生命周期由对象的生命周期自动管理。

        cout << "~Date()" << endl;
    }

private:
    // C++11支持，声明时给缺省值
    int _year = 1;
    int _month = 1;
    int _day = 1;
};

class Stack
{
public:
    Stack(size_t capacity = 3)
    // 表示 Stack 类的构造函数的参数 capacity 有一个默认值 3
    // 这是C++构造函数的一个特性，它允许在创建对象时省略某些参数，如果省略了这些参数，那么就会使用这些参数的默认值。
    // 使用默认参数的方式，你可以这样创建 Stack 对象：
    // Stack st1;       // 使用默认的容量3
    // Stack st2(5);    // 指定容量为5
    {
        cout << "Stack(size_t capacity = 3)" << endl;
        _a = (int *)malloc(sizeof(int) * capacity);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败!!!");
        }
        _capacity = capacity;
        _top = 0;
    }

    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _capacity = _top = 0;
        _a = nullptr;
    }

private:
    int *_a;
    int _capacity;
    int _top;
};

class MyQueue
{
    // 默认生成析构函数，行为跟构造类似
    // 内置类型成员不做处理
    // 自定义类型成员会去调用他的析构
private:
    Stack _pushst;
    Stack _popst;
    int _size = 1;
};

// 21:17继续
int main()
{
    Date d1;
    Stack st1;
    MyQueue mq;

    return 0;
}